home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / MIDI.p < prev    next >
Encoding:
Text File  |  1996-05-01  |  17.5 KB  |  522 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MIDI.p
  3.  
  4.      Contains:    MIDI Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT MIDI;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __MIDI__}
  28. {$SETC __MIDI__ := 1}
  29.  
  30. {$I+}
  31. {$SETC MIDIIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __ERRORS__}
  35. {$I Errors.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __MIXEDMODE__}
  41. {$I MixedMode.p}
  42. {$ENDC}
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48. {$IFC FOR_SYSTEM7_ONLY }
  49. {
  50.                         * * *  N O T E  * * * 
  51.  
  52.     This file has been updated to include MIDI 2.0 interfaces.  
  53.     
  54.     The MIDI 2.0 interfaces were developed for the classic 68K runtime.
  55.     Since then, Apple has created the PowerPC and CFM 68K runtimes.
  56.     Currently, the extra functions in MIDI 2.0 are not in InterfaceLib
  57.     and thus not callable from PowerPC and CFM 68K runtimes (you'll
  58.     get a linker error).  
  59. }
  60.  
  61. CONST
  62.     midiMaxNameLen                = 31;                            { maximum number of characters in port and client names }
  63.                                                                 {  Time formats  }
  64.     midiFormatMSec                = 0;                            { milliseconds }
  65.     midiFormatBeats                = 1;                            { beats }
  66.     midiFormat24fpsBit            = 2;                            { 24 frames/sec. }
  67.     midiFormat25fpsBit            = 3;                            { 25 frames/sec. }
  68.     midiFormat30fpsDBit            = 4;                            { 30 frames/sec. drop-frame }
  69.     midiFormat30fpsBit            = 5;                            { 30 frames/sec. }
  70.     midiFormat24fpsQF            = 6;                            { 24 frames/sec. longInt format  }
  71.     midiFormat25fpsQF            = 7;                            { 25 frames/sec. longInt format  }
  72.     midiFormat30fpsDQF            = 8;                            { 30 frames/sec. drop-frame longInt format  }
  73.     midiFormat30fpsQF            = 9;                            { 30 frames/sec. longInt format  }
  74.     midiInternalSync            = 0;                            { internal sync }
  75.     midiExternalSync            = 1;                            { external sync }
  76.                                                                 {  Port types }
  77.     midiPortTypeTime            = 0;                            { time port }
  78.     midiPortTypeInput            = 1;                            { input port }
  79.     midiPortTypeOutput            = 2;                            { output port }
  80.     midiPortTypeTimeInv            = 3;                            { invisible time port }
  81.     midiPortInvisible            = $8000;                        { logical OR this to other types to make invisible ports }
  82.     midiPortTypeMask            = $0007;                        { logical AND with this to convert new port types to old, }
  83.                                                                 { ie. to strip the property bits }
  84.                                                                 {  OffsetTimes   }
  85.     midiGetEverything            = $7FFFFFFF;                    { get all packets, regardless of time stamps }
  86.     midiGetNothing                = $80000000;                    { get no packets, regardless of time stamps }
  87.     midiGetCurrent                = $00000000;                    { get current packets only }
  88.  
  89. {
  90.     MIDI data and messages are passed in MIDIPacket records (see below).
  91.     The first byte of every MIDIPacket contains a set of flags
  92.  
  93.     bits 0-1    00 = new MIDIPacket, not continued
  94.                      01 = begining of continued MIDIPacket
  95.                      10 = end of continued MIDIPacket
  96.                      11 = continuation
  97.     bits 2-3     reserved
  98.  
  99.     bits 4-6      000 = packet contains MIDI data
  100.  
  101.                   001 = packet contains MIDI Manager message
  102.  
  103.     bit 7         0 = MIDIPacket has valid stamp
  104.                   1 = stamp with current clock
  105. }
  106.     midiContMask                = $03;
  107.     midiNoCont                    = $00;
  108.     midiStartCont                = $01;
  109.     midiMidCont                    = $03;
  110.     midiEndCont                    = $02;
  111.     midiTypeMask                = $70;
  112.     midiMsgType                    = $00;
  113.     midiMgrType                    = $10;
  114.     midiTimeStampMask            = $80;
  115.     midiTimeStampCurrent        = $80;
  116.     midiTimeStampValid            = $00;                            {  MIDIPacket command words (the first word in the data field for midiMgrType messages)  }
  117.     midiOverflowErr                = $0001;
  118.     midiSCCErr                    = $0002;
  119.     midiPacketErr                = $0003;                        { all command words less than this value are error indicators }
  120.     midiMaxErr                    = $00FF;                        {  Valid results to be returned by readHooks  }
  121.     midiKeepPacket                = 0;
  122.     midiMorePacket                = 1;
  123.     midiNoMorePacket            = 2;
  124.     midiHoldPacket                = 3;                            {  Driver calls  }
  125.     midiOpenDriver                = 1;
  126.     midiCloseDriver                = 2;
  127.  
  128.     mdvrAbortNotesOff            = 0;                            { abort previous mdvrNotesOff request }
  129.     mdvrChanNotesOff            = 1;                            { generate channel note off messages }
  130.     mdvrAllNotesOff                = 2;                            { generate all note off messages }
  131.     mdvrStopOut                    = 0;                            { stop calling MDVROut temporarily }
  132.     mdvrStartOut                = 1;                            { resume calling MDVROut }
  133.  
  134.  
  135. TYPE
  136.     MIDIPacketPtr = ^MIDIPacket;
  137.     MIDIPacket = PACKED RECORD
  138.         flags:                    UInt8;
  139.         len:                    UInt8;
  140.         tStamp:                    LONGINT;
  141.         data:                    PACKED ARRAY [0..248] OF UInt8;
  142.     END;
  143.  
  144.     MIDIReadHookProcPtr = ProcPtr;  { FUNCTION MIDIReadHook(myPacket: MIDIPacketPtr; myRefCon: LONGINT): INTEGER; }
  145.  
  146.     MIDITimeProcPtr = ProcPtr;  { PROCEDURE MIDITime(curTime: LONGINT; myRefCon: LONGINT); }
  147.  
  148.     MIDIConnectionProcPtr = ProcPtr;  { PROCEDURE MIDIConnection(refnum: INTEGER; refcon: LONGINT; portType: INTEGER; clientID: OSType; portID: OSType; connect: BOOLEAN; direction: INTEGER); }
  149.  
  150.     MDVRCommProcPtr = ProcPtr;  { FUNCTION MDVRComm(refnum: INTEGER; request: INTEGER; refCon: LONGINT): LONGINT; }
  151.  
  152.     MDVRTimeCodeProcPtr = ProcPtr;  { PROCEDURE MDVRTimeCode(refnum: INTEGER; newFormat: INTEGER; refCon: LONGINT); }
  153.  
  154.     MDVRReadProcPtr = ProcPtr;  { PROCEDURE MDVRRead(midiChars: CStringPtr; length: INTEGER; refCon: LONGINT); }
  155.  
  156.     MIDIReadHookUPP = UniversalProcPtr;
  157.     MIDITimeUPP = UniversalProcPtr;
  158.     MIDIConnectionUPP = UniversalProcPtr;
  159.     MDVRCommUPP = UniversalProcPtr;
  160.     MDVRTimeCodeUPP = UniversalProcPtr;
  161.     MDVRReadUPP = UniversalProcPtr;
  162.     MIDIClkInfoPtr = ^MIDIClkInfo;
  163.     MIDIClkInfo = RECORD
  164.         syncType:                INTEGER;                                { synchronization external/internal }
  165.         curTime:                LONGINT;                                { current value of port's clock }
  166.         format:                    INTEGER;                                { time code format }
  167.     END;
  168.  
  169.     MIDIIDRecPtr = ^MIDIIDRec;
  170.     MIDIIDRec = RECORD
  171.         clientID:                OSType;
  172.         portID:                    OSType;
  173.     END;
  174.  
  175.     MIDIPortInfoPtr = ^MIDIPortInfo;
  176.     MIDIPortInfo = RECORD
  177.         portType:                INTEGER;                                { type of port }
  178.         timeBase:                MIDIIDRec;                                { MIDIIDRec for time base }
  179.         numConnects:            INTEGER;                                { number of connections }
  180.         cList:                    ARRAY [0..0] OF MIDIIDRec;                { ARRAY [1..numConnects] of MIDIIDRec }
  181.     END;
  182.  
  183.     MIDIPortInfoHdl                        = ^MIDIPortInfoPtr;
  184.     MIDIPortInfoHandle                    = ^MIDIPortInfoPtr;
  185.     MIDIPortParamsPtr = ^MIDIPortParams;
  186.     MIDIPortParams = RECORD
  187.         portID:                    OSType;                                    { ID of port, unique within client }
  188.         portType:                INTEGER;                                { Type of port - input, output, time, etc. }
  189.         timeBase:                INTEGER;                                { refnum of time base, 0 if none }
  190.         offsetTime:                LONGINT;                                { offset for current time stamps }
  191.         readHook:                MIDIReadHookProcPtr;                    { routine to call when input data is valid }
  192.         refCon:                    LONGINT;                                { refcon for port (for client use) }
  193.         initClock:                MIDIClkInfo;                            { initial settings for a time base }
  194.         name:                    Str255;                                    { name of the port, This is a real live string, not a ptr. }
  195.     END;
  196.  
  197.     MIDIIDListPtr = ^MIDIIDList;
  198.     MIDIIDList = RECORD
  199.         numIDs:                    INTEGER;
  200.         list:                    ARRAY [0..0] OF OSType;
  201.     END;
  202.  
  203.     MIDIIDListHdl                        = ^MIDIIDListPtr;
  204.     MIDIIDListHandle                    = ^MIDIIDListPtr;
  205. {  MDVR Control structs }
  206.     MDVRInCtlRecPtr = ^MDVRInCtlRec;
  207.     MDVRInCtlRec = RECORD
  208.         timeCodeClock:            INTEGER;                                { refnum of time base for time code }
  209.         timeCodeFormat:            INTEGER;                                { format of time code output }
  210.         readProc:                MDVRReadProcPtr;                        { proc to call with intput characters }
  211.         commProc:                MDVRCommProcPtr;                        { proc to call for handshaking }
  212.         refCon:                    LONGINT;                                { refCon passed to readProc, commProc }
  213.     END;
  214.  
  215.     MDVRInCtlPtr                        = ^MDVRInCtlRec;
  216.     MDVROutCtlRecPtr = ^MDVROutCtlRec;
  217.     MDVROutCtlRec = RECORD
  218.         timeCodeClock:            INTEGER;                                { time base driven by time code }
  219.         timeCodeFormat:            INTEGER;                                { format of time code to listen to }
  220.         timeCodeProc:            MDVRTimeCodeProcPtr;                    { proc called on time code fmt change }
  221.         commProc:                MDVRCommProcPtr;                        { proc called for handshaking }
  222.         refCon:                    LONGINT;                                { refCon passed to timeCodeProc }
  223.         timeCodeFilter:            BOOLEAN;                                { filter time code if true }
  224.         padding:                SInt8;                                    { unused pad byte }
  225.         midiMsgTicks:            LONGINT;                                { value of Ticks when MIDI msg rcvd }
  226.         timeCodeTicks:            LONGINT;                                { value of Ticks when time code rcvd }
  227.     END;
  228.  
  229.     MDVROutCtlPtr                        = ^MDVROutCtlRec;
  230.     MDVRPtr                                = Ptr;
  231. FUNCTION MIDIVersion: NumVersion;
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $203C, $0000, $0004, $A800;
  234.     {$ENDC}
  235. FUNCTION MIDISignIn(clientID: OSType; refCon: LONGINT; icon: Handle; name: Str255): OSErr;
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $203C, $0004, $0004, $A800;
  238.     {$ENDC}
  239. PROCEDURE MIDISignOut(clientID: OSType);
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $203C, $0008, $0004, $A800;
  242.     {$ENDC}
  243. FUNCTION MIDIGetClients: MIDIIDListHandle;
  244.     {$IFC NOT GENERATINGCFM}
  245.     INLINE $203C, $000C, $0004, $A800;
  246.     {$ENDC}
  247. PROCEDURE MIDIGetClientName(clientID: OSType; VAR name: Str255);
  248.     {$IFC NOT GENERATINGCFM}
  249.     INLINE $203C, $0010, $0004, $A800;
  250.     {$ENDC}
  251. PROCEDURE MIDISetClientName(clientID: OSType; name: Str255);
  252.     {$IFC NOT GENERATINGCFM}
  253.     INLINE $203C, $0014, $0004, $A800;
  254.     {$ENDC}
  255. FUNCTION MIDIGetPorts(clientID: OSType): MIDIIDListHandle;
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $203C, $0018, $0004, $A800;
  258.     {$ENDC}
  259. FUNCTION MIDIAddPort(clientID: OSType; BufSize: INTEGER; VAR refnum: INTEGER; init: MIDIPortParamsPtr): OSErr;
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $203C, $001C, $0004, $A800;
  262.     {$ENDC}
  263. FUNCTION MIDIGetPortInfo(clientID: OSType; portID: OSType): MIDIPortInfoHandle;
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $203C, $0020, $0004, $A800;
  266.     {$ENDC}
  267. FUNCTION MIDIConnectData(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $203C, $0024, $0004, $A800;
  270.     {$ENDC}
  271. FUNCTION MIDIUnConnectData(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $203C, $0028, $0004, $A800;
  274.     {$ENDC}
  275. FUNCTION MIDIConnectTime(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $203C, $002C, $0004, $A800;
  278.     {$ENDC}
  279. FUNCTION MIDIUnConnectTime(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  280.     {$IFC NOT GENERATINGCFM}
  281.     INLINE $203C, $0030, $0004, $A800;
  282.     {$ENDC}
  283. PROCEDURE MIDIFlush(refnum: INTEGER);
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $203C, $0034, $0004, $A800;
  286.     {$ENDC}
  287. FUNCTION MIDIGetReadHook(refnum: INTEGER): ProcPtr;
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $203C, $0038, $0004, $A800;
  290.     {$ENDC}
  291. PROCEDURE MIDISetReadHook(refnum: INTEGER; hook: ProcPtr);
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $203C, $003C, $0004, $A800;
  294.     {$ENDC}
  295. PROCEDURE MIDIGetPortName(clientID: OSType; portID: OSType; VAR name: Str255);
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $203C, $0040, $0004, $A800;
  298.     {$ENDC}
  299. PROCEDURE MIDISetPortName(clientID: OSType; portID: OSType; name: Str255);
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $203C, $0044, $0004, $A800;
  302.     {$ENDC}
  303. PROCEDURE MIDIWakeUp(refnum: INTEGER; time: LONGINT; period: LONGINT; timeProc: MIDITimeProcPtr);
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $203C, $0048, $0004, $A800;
  306.     {$ENDC}
  307. PROCEDURE MIDIRemovePort(refnum: INTEGER);
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $203C, $004C, $0004, $A800;
  310.     {$ENDC}
  311. FUNCTION MIDIGetSync(refnum: INTEGER): INTEGER;
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $203C, $0050, $0004, $A800;
  314.     {$ENDC}
  315. PROCEDURE MIDISetSync(refnum: INTEGER; sync: INTEGER);
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $203C, $0054, $0004, $A800;
  318.     {$ENDC}
  319. FUNCTION MIDIGetCurTime(refnum: INTEGER): LONGINT;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $203C, $0058, $0004, $A800;
  322.     {$ENDC}
  323. PROCEDURE MIDISetCurTime(refnum: INTEGER; time: LONGINT);
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $203C, $005C, $0004, $A800;
  326.     {$ENDC}
  327. PROCEDURE MIDIStartTime(refnum: INTEGER);
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $203C, $0060, $0004, $A800;
  330.     {$ENDC}
  331. PROCEDURE MIDIStopTime(refnum: INTEGER);
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $203C, $0064, $0004, $A800;
  334.     {$ENDC}
  335. PROCEDURE MIDIPoll(refnum: INTEGER; offsetTime: LONGINT);
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $203C, $0068, $0004, $A800;
  338.     {$ENDC}
  339. FUNCTION MIDIWritePacket(refnum: INTEGER; packet: MIDIPacketPtr): OSErr;
  340.     {$IFC NOT GENERATINGCFM}
  341.     INLINE $203C, $006C, $0004, $A800;
  342.     {$ENDC}
  343. FUNCTION MIDIWorldChanged(clientID: OSType): BOOLEAN;
  344.     {$IFC NOT GENERATINGCFM}
  345.     INLINE $203C, $0070, $0004, $A800;
  346.     {$ENDC}
  347. FUNCTION MIDIGetOffsetTime(refnum: INTEGER): LONGINT;
  348.     {$IFC NOT GENERATINGCFM}
  349.     INLINE $203C, $0074, $0004, $A800;
  350.     {$ENDC}
  351. PROCEDURE MIDISetOffsetTime(refnum: INTEGER; offsetTime: LONGINT);
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $203C, $0078, $0004, $A800;
  354.     {$ENDC}
  355. FUNCTION MIDIConvertTime(srcFormat: INTEGER; dstFormat: INTEGER; time: LONGINT): LONGINT;
  356.     {$IFC NOT GENERATINGCFM}
  357.     INLINE $203C, $007C, $0004, $A800;
  358.     {$ENDC}
  359. FUNCTION MIDIGetRefCon(refnum: INTEGER): LONGINT;
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $203C, $0080, $0004, $A800;
  362.     {$ENDC}
  363. PROCEDURE MIDISetRefCon(refnum: INTEGER; refCon: LONGINT);
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $203C, $0084, $0004, $A800;
  366.     {$ENDC}
  367. FUNCTION MIDIGetClRefCon(clientID: OSType): LONGINT;
  368.     {$IFC NOT GENERATINGCFM}
  369.     INLINE $203C, $0088, $0004, $A800;
  370.     {$ENDC}
  371. PROCEDURE MIDISetClRefCon(clientID: OSType; refCon: LONGINT);
  372.     {$IFC NOT GENERATINGCFM}
  373.     INLINE $203C, $008C, $0004, $A800;
  374.     {$ENDC}
  375. FUNCTION MIDIGetTCFormat(refnum: INTEGER): INTEGER;
  376.     {$IFC NOT GENERATINGCFM}
  377.     INLINE $203C, $0090, $0004, $A800;
  378.     {$ENDC}
  379. PROCEDURE MIDISetTCFormat(refnum: INTEGER; format: INTEGER);
  380.     {$IFC NOT GENERATINGCFM}
  381.     INLINE $203C, $0094, $0004, $A800;
  382.     {$ENDC}
  383. PROCEDURE MIDISetRunRate(refnum: INTEGER; rate: INTEGER; time: LONGINT);
  384.     {$IFC NOT GENERATINGCFM}
  385.     INLINE $203C, $0098, $0004, $A800;
  386.     {$ENDC}
  387. FUNCTION MIDIGetClientIcon(clientID: OSType): Handle;
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $203C, $009C, $0004, $A800;
  390.     {$ENDC}
  391. FUNCTION MIDICallAddress(callNum: INTEGER): ProcPtr;
  392.     {$IFC NOT GENERATINGCFM}
  393.     INLINE $203C, $00A4, $0004, $A800;
  394.     {$ENDC}
  395. PROCEDURE MIDISetConnectionProc(refNum: INTEGER; connectionProc: ProcPtr; refCon: LONGINT);
  396.     {$IFC NOT GENERATINGCFM}
  397.     INLINE $203C, $00A8, $0004, $A800;
  398.     {$ENDC}
  399. PROCEDURE MIDIGetConnectionProc(refnum: INTEGER; VAR connectionProc: ProcPtr; VAR refCon: LONGINT);
  400.     {$IFC NOT GENERATINGCFM}
  401.     INLINE $203C, $00AC, $0004, $A800;
  402.     {$ENDC}
  403. PROCEDURE MIDIDiscardPacket(refnum: INTEGER; packet: MIDIPacketPtr);
  404.     {$IFC NOT GENERATINGCFM}
  405.     INLINE $203C, $00B0, $0004, $A800;
  406.     {$ENDC}
  407. FUNCTION MDVRSignIn(clientID: OSType; refCon: LONGINT; icon: Handle; VAR name: Str255): OSErr;
  408.     {$IFC NOT GENERATINGCFM}
  409.     INLINE $203C, $00B4, $0004, $A800;
  410.     {$ENDC}
  411. PROCEDURE MDVRSignOut(clientID: OSType);
  412.     {$IFC NOT GENERATINGCFM}
  413.     INLINE $203C, $00B8, $0004, $A800;
  414.     {$ENDC}
  415. FUNCTION MDVROpen(portType: INTEGER; refnum: INTEGER): MDVRPtr;
  416.     {$IFC NOT GENERATINGCFM}
  417.     INLINE $203C, $00BC, $0004, $A800;
  418.     {$ENDC}
  419. PROCEDURE MDVRClose(driverPtr: MDVRPtr);
  420.     {$IFC NOT GENERATINGCFM}
  421.     INLINE $203C, $00C0, $0004, $A800;
  422.     {$ENDC}
  423. PROCEDURE MDVRControlIn(portPtr: MDVRPtr; inputCtl: MDVRInCtlPtr);
  424.     {$IFC NOT GENERATINGCFM}
  425.     INLINE $203C, $00C4, $0004, $A800;
  426.     {$ENDC}
  427. PROCEDURE MDVRControlOut(portPtr: MDVRPtr; outputCtl: MDVROutCtlPtr);
  428.     {$IFC NOT GENERATINGCFM}
  429.     INLINE $203C, $00C8, $0004, $A800;
  430.     {$ENDC}
  431. PROCEDURE MDVRIn(portPtr: MDVRPtr);
  432.     {$IFC NOT GENERATINGCFM}
  433.     INLINE $203C, $00CC, $0004, $A800;
  434.     {$ENDC}
  435. PROCEDURE MDVROut(portPtr: MDVRPtr; dataPtr: CStringPtr; length: INTEGER);
  436.     {$IFC NOT GENERATINGCFM}
  437.     INLINE $203C, $00D0, $0004, $A800;
  438.     {$ENDC}
  439. PROCEDURE MDVRNotesOff(portPtr: MDVRPtr; mode: INTEGER);
  440.     {$IFC NOT GENERATINGCFM}
  441.     INLINE $203C, $00D4, $0004, $A800;
  442.     {$ENDC}
  443.  
  444. CONST
  445.     uppMIDIReadHookProcInfo = $000003E0;
  446.     uppMIDITimeProcInfo = $000003C0;
  447.     uppMIDIConnectionProcInfo = $0009FB80;
  448.     uppMDVRCommProcInfo = $00000EB0;
  449.     uppMDVRTimeCodeProcInfo = $00000E80;
  450.     uppMDVRReadProcInfo = $00000EC0;
  451.  
  452. FUNCTION NewMIDIReadHookProc(userRoutine: MIDIReadHookProcPtr): MIDIReadHookUPP;
  453.     {$IFC NOT GENERATINGCFM }
  454.     INLINE $2E9F;
  455.     {$ENDC}
  456.  
  457. FUNCTION NewMIDITimeProc(userRoutine: MIDITimeProcPtr): MIDITimeUPP;
  458.     {$IFC NOT GENERATINGCFM }
  459.     INLINE $2E9F;
  460.     {$ENDC}
  461.  
  462. FUNCTION NewMIDIConnectionProc(userRoutine: MIDIConnectionProcPtr): MIDIConnectionUPP;
  463.     {$IFC NOT GENERATINGCFM }
  464.     INLINE $2E9F;
  465.     {$ENDC}
  466.  
  467. FUNCTION NewMDVRCommProc(userRoutine: MDVRCommProcPtr): MDVRCommUPP;
  468.     {$IFC NOT GENERATINGCFM }
  469.     INLINE $2E9F;
  470.     {$ENDC}
  471.  
  472. FUNCTION NewMDVRTimeCodeProc(userRoutine: MDVRTimeCodeProcPtr): MDVRTimeCodeUPP;
  473.     {$IFC NOT GENERATINGCFM }
  474.     INLINE $2E9F;
  475.     {$ENDC}
  476.  
  477. FUNCTION NewMDVRReadProc(userRoutine: MDVRReadProcPtr): MDVRReadUPP;
  478.     {$IFC NOT GENERATINGCFM }
  479.     INLINE $2E9F;
  480.     {$ENDC}
  481.  
  482. FUNCTION CallMIDIReadHookProc(myPacket: MIDIPacketPtr; myRefCon: LONGINT; userRoutine: MIDIReadHookUPP): INTEGER;
  483.     {$IFC NOT GENERATINGCFM}
  484.     INLINE $205F, $4E90;
  485.     {$ENDC}
  486.  
  487. PROCEDURE CallMIDITimeProc(curTime: LONGINT; myRefCon: LONGINT; userRoutine: MIDITimeUPP);
  488.     {$IFC NOT GENERATINGCFM}
  489.     INLINE $205F, $4E90;
  490.     {$ENDC}
  491.  
  492. PROCEDURE CallMIDIConnectionProc(refnum: INTEGER; refcon: LONGINT; portType: INTEGER; clientID: OSType; portID: OSType; connect: BOOLEAN; direction: INTEGER; userRoutine: MIDIConnectionUPP);
  493.     {$IFC NOT GENERATINGCFM}
  494.     INLINE $205F, $4E90;
  495.     {$ENDC}
  496.  
  497. FUNCTION CallMDVRCommProc(refnum: INTEGER; request: INTEGER; refCon: LONGINT; userRoutine: MDVRCommUPP): LONGINT;
  498.     {$IFC NOT GENERATINGCFM}
  499.     INLINE $205F, $4E90;
  500.     {$ENDC}
  501.  
  502. PROCEDURE CallMDVRTimeCodeProc(refnum: INTEGER; newFormat: INTEGER; refCon: LONGINT; userRoutine: MDVRTimeCodeUPP);
  503.     {$IFC NOT GENERATINGCFM}
  504.     INLINE $205F, $4E90;
  505.     {$ENDC}
  506.  
  507. PROCEDURE CallMDVRReadProc(midiChars: CStringPtr; length: INTEGER; refCon: LONGINT; userRoutine: MDVRReadUPP);
  508.     {$IFC NOT GENERATINGCFM}
  509.     INLINE $205F, $4E90;
  510.     {$ENDC}
  511. {$ENDC}
  512. {$ALIGN RESET}
  513. {$POP}
  514.  
  515. {$SETC UsingIncludes := MIDIIncludes}
  516.  
  517. {$ENDC} {__MIDI__}
  518.  
  519. {$IFC NOT UsingIncludes}
  520.  END.
  521. {$ENDC}
  522.